 /*******************************************************************************
  * Copyright (c) 2000, 2006 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ui.internal.dialogs;

 import com.ibm.icu.text.Collator;
 import java.util.ArrayList ;
 import java.util.Arrays ;
 import java.util.HashMap ;
 import java.util.Iterator ;
 import java.util.List ;

 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.jface.dialogs.IDialogSettings;
 import org.eclipse.jface.dialogs.ProgressMonitorDialog;
 import org.eclipse.jface.resource.ImageDescriptor;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.DisposeEvent;
 import org.eclipse.swt.events.DisposeListener;
 import org.eclipse.swt.events.SelectionAdapter;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.graphics.Font;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.graphics.Point;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Layout;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.TableColumn;
 import org.eclipse.swt.widgets.TableItem;
 import org.eclipse.ui.IEditorDescriptor;
 import org.eclipse.ui.IEditorInput;
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IEditorReference;
 import org.eclipse.ui.IEditorRegistry;
 import org.eclipse.ui.IPerspectiveDescriptor;
 import org.eclipse.ui.IWorkbenchPage;
 import org.eclipse.ui.IWorkbenchWindow;
 import org.eclipse.ui.PartInitException;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.dialogs.SelectionDialog;
 import org.eclipse.ui.internal.IWorkbenchGraphicConstants;
 import org.eclipse.ui.internal.IWorkbenchHelpContextIds;
 import org.eclipse.ui.internal.WorkbenchImages;
 import org.eclipse.ui.internal.WorkbenchMessages;
 import org.eclipse.ui.internal.WorkbenchPage;
 import org.eclipse.ui.internal.WorkbenchPartReference;
 import org.eclipse.ui.internal.WorkbenchPlugin;
 import org.eclipse.ui.internal.layout.CellData;
 import org.eclipse.ui.internal.layout.CellLayout;
 import org.eclipse.ui.internal.layout.Row;
 import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;

 /**
  * Implements a dialog showing all opened editors in the workbench
  * and the recent closed editors
  */
 public class WorkbenchEditorsDialog extends SelectionDialog {

     private IWorkbenchWindow window;

     private Table editorsTable;

     private Button saveSelected;

     private Button closeSelected;

     private Button selectClean;

     private Button invertSelection;

     private Button allSelection;

     private boolean showAllPersp = false;

     private int sortColumn;

     private List elements = new ArrayList ();

     private HashMap imageCache = new HashMap (11);

     private HashMap disabledImageCache = new HashMap (11);

     private boolean reverse = false;

     private Collator collator = Collator.getInstance();

     private Rectangle bounds;

     private int columnsWidth[];

     private static final String SORT = "sort"; //$NON-NLS-1$

     private static final String ALLPERSP = "allPersp"; //$NON-NLS-1$

     private static final String BOUNDS = "bounds"; //$NON-NLS-1$

     private static final String COLUMNS = "columns"; //$NON-NLS-1$

     private SelectionListener headerListener = new SelectionAdapter() {
         public void widgetSelected(SelectionEvent e) {
             int index = editorsTable.indexOf((TableColumn) e.widget);
             if (index == sortColumn) {
                 reverse = !reverse;
             } else {
                 sortColumn = index;
             }
             updateItems();
         }
     };

     /**
      * Constructor for WorkbenchEditorsDialog.
      *
      * @param window the window
      */
     public WorkbenchEditorsDialog(IWorkbenchWindow window) {
         super(window.getShell());
         this.window = window;
         setTitle(WorkbenchMessages.WorkbenchEditorsDialog_title);
         setShellStyle(getShellStyle() | SWT.RESIZE);

         IDialogSettings s = getDialogSettings();
         if (s.get(ALLPERSP) == null) {
             sortColumn = 0;
         } else {
             showAllPersp = s.getBoolean(ALLPERSP);
             sortColumn = s.getInt(SORT);
             String [] array = s.getArray(BOUNDS);
             if (array != null) {
                 bounds = new Rectangle(0, 0, 0, 0);
                 bounds.x = new Integer (array[0]).intValue();
                 bounds.y = new Integer (array[1]).intValue();
                 bounds.width = new Integer (array[2]).intValue();
                 bounds.height = new Integer (array[3]).intValue();
             }
             array = s.getArray(COLUMNS);
             if (array != null) {
                 columnsWidth = new int[array.length];
                 for (int i = 0; i < columnsWidth.length; i++) {
                     columnsWidth[i] = new Integer (array[i]).intValue();
                 }
             }
         }
     }

     /* (non-Javadoc)
      * Method declared on Window.
      */
     protected void configureShell(Shell newShell) {
         super.configureShell(newShell);
         PlatformUI.getWorkbench().getHelpSystem().setHelp(newShell,
                 IWorkbenchHelpContextIds.WORKBENCH_EDITORS_DIALOG);
     }

     /*
      * (non-Javadoc)
      * @see org.eclipse.jface.dialogs.Dialog#createButtonsForButtonBar(org.eclipse.swt.widgets.Composite)
      */
     protected void createButtonsForButtonBar(Composite parent) {
         // Typically we would use the parent's createButtonsForButtonBar.
 // However, we only want a Cancel button and not an OK button. The
 // OK button will be used later (in createDialogArea) to activate
 // the selected editor.
 createButton(parent, IDialogConstants.CANCEL_ID,
                 IDialogConstants.CANCEL_LABEL, false);
         Button button = getButton(IDialogConstants.CANCEL_ID);
         if (button != null) {
             button.setText(WorkbenchMessages.WorkbenchEditorsDialog_close);
         }

     }

     /**
      * Initialize the dialog bounds with the bounds saved
      * from the settings.
      */
     protected void initializeBounds() {
         if (bounds != null) {
             getShell().setBounds(bounds);
         } else {
             super.initializeBounds();
         }
     }

     /**
      * Creates the contents of this dialog, initializes the
      * listener and the update thread.
      */
     protected Control createDialogArea(Composite parent) {

         initializeDialogUnits(parent);

         Font font = parent.getFont();

         Composite dialogArea = new Composite(parent, SWT.NONE);
         CellLayout dialogAreaLayout = new CellLayout(1)
                 .setMargins(
                         convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN),
                         convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN))
                 .setSpacing(
                         convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING),
                         convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING))
                 .setRow(1, Row.growing());
         dialogArea.setLayout(dialogAreaLayout);
         dialogArea.setLayoutData(new GridData(GridData.FILL_BOTH));

         //Label over the table
 Label l = new Label(dialogArea, SWT.NONE);
         l.setText(WorkbenchMessages.WorkbenchEditorsDialog_label);
         l.setFont(font);
         l.setLayoutData(new CellData().align(SWT.FILL, SWT.CENTER));
         //Table showing the editors name, full path and perspective
 editorsTable = new Table(dialogArea, SWT.MULTI | SWT.BORDER
                 | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);
         editorsTable.setLinesVisible(true);
         editorsTable.setHeaderVisible(true);
         editorsTable.setFont(font);

         final int height = 16 * editorsTable.getItemHeight();
         final int width = (int) (2.5 * height);

         CellData tableData = new CellData().align(SWT.FILL, SWT.FILL).setHint(
                 CellData.OVERRIDE, width, height);

         editorsTable.setLayoutData(tableData);
         editorsTable.setLayout(new Layout() {
             protected Point computeSize(Composite composite, int wHint,
                     int hHint, boolean flushCache) {
                 return new Point(width, height);
             }

             protected void layout(Composite composite, boolean flushCache) {
                 TableColumn c[] = editorsTable.getColumns();
                 if (columnsWidth == null) {
                     int w = editorsTable.getClientArea().width;
                     c[0].setWidth(w * 1 / 3);
                     c[1].setWidth(w - c[0].getWidth());
                 } else {
                     c[0].setWidth(columnsWidth[0]);
                     c[1].setWidth(columnsWidth[1]);
                 }
                 editorsTable.setLayout(null);
             }
         });
         //Name column
 TableColumn tc = new TableColumn(editorsTable, SWT.NONE);
         tc.setResizable(true);
         tc.setText(WorkbenchMessages.WorkbenchEditorsDialog_name);
         tc.addSelectionListener(headerListener);
         //Full path column
 tc = new TableColumn(editorsTable, SWT.NONE);
         tc.setResizable(true);
         tc.setText(WorkbenchMessages.WorkbenchEditorsDialog_path);
         tc.addSelectionListener(headerListener);

         // A composite for selection option buttons
 Composite selectionButtons = new Composite(dialogArea, SWT.NULL);
         Label compLabel = new Label(selectionButtons, SWT.NULL);
         compLabel.setFont(font);
         GridLayout layout = new GridLayout();
         layout.numColumns = 4;
         selectionButtons.setLayout(layout);

         //Select clean editors button
 selectClean = new Button(selectionButtons, SWT.PUSH);
         selectClean.setText(WorkbenchMessages.WorkbenchEditorsDialog_selectClean);
         selectClean.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 editorsTable.setSelection(selectClean(editorsTable.getItems()));
                 updateButtons();
             }
         });
         selectClean.setFont(font);
         setButtonLayoutData(selectClean);

         //Invert selection button
 invertSelection = new Button(selectionButtons, SWT.PUSH);
         invertSelection.setText(WorkbenchMessages.WorkbenchEditorsDialog_invertSelection);
         invertSelection.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 editorsTable.setSelection(invertedSelection(editorsTable
                         .getItems(), editorsTable.getSelection()));
                 updateButtons();
             }
         });
         invertSelection.setFont(font);
         setButtonLayoutData(invertSelection);

         //Select all button
 allSelection = new Button(selectionButtons, SWT.PUSH);
         allSelection.setText(WorkbenchMessages.WorkbenchEditorsDialog_allSelection);
         allSelection.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 editorsTable.setSelection(editorsTable.getItems());
                 updateButtons();
             }
         });
         allSelection.setFont(font);
         setButtonLayoutData(allSelection);

         // A composite for selected editor action buttons
 Composite actionButtons = new Composite(dialogArea, SWT.NULL);
         Label actLabel = new Label(actionButtons, SWT.NULL);
         actLabel.setFont(font);
         GridLayout actLayout = new GridLayout();
         actLayout.numColumns = 4;
         actionButtons.setLayout(actLayout);

         // Activate selected editor button
 createButton(actionButtons, IDialogConstants.OK_ID, WorkbenchMessages.WorkbenchEditorsDialog_activate,
                 true);

         //Close selected editors button
 closeSelected = new Button(actionButtons, SWT.PUSH);
         closeSelected.setText(WorkbenchMessages.WorkbenchEditorsDialog_closeSelected);
         closeSelected.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 closeItems(editorsTable.getSelection());
             }
         });
         closeSelected.setFont(font);
         setButtonLayoutData(closeSelected);

         //Save selected editors button
 saveSelected = new Button(actionButtons, SWT.PUSH);
         saveSelected.setText(WorkbenchMessages.WorkbenchEditorsDialog_saveSelected);
         saveSelected.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 saveItems(editorsTable.getSelection(), null);
             }
         });
         saveSelected.setFont(font);
         setButtonLayoutData(saveSelected);

         //Show only active perspective button
 final Button showAllPerspButton = new Button(dialogArea, SWT.CHECK);
         showAllPerspButton.setText(WorkbenchMessages.WorkbenchEditorsDialog_showAllPersp);
         showAllPerspButton.setSelection(showAllPersp);
         showAllPerspButton.setFont(font);
         setButtonLayoutData(showAllPerspButton);
         showAllPerspButton.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 showAllPersp = showAllPerspButton.getSelection();
                 updateItems();
             }
         });
         //Create the items and update buttons state
 updateItems();
         updateButtons();

         editorsTable.addSelectionListener(new SelectionAdapter() {
             public void widgetSelected(SelectionEvent e) {
                 updateButtons();
             }

             public void widgetDefaultSelected(SelectionEvent e) {
                 okPressed();
             }
         });
         editorsTable.addDisposeListener(new DisposeListener() {
             public void widgetDisposed(DisposeEvent e) {
                 for (Iterator images = imageCache.values().iterator(); images
                         .hasNext();) {
                     Image i = (Image) images.next();
                     i.dispose();
                 }
                 for (Iterator images = disabledImageCache.values().iterator(); images
                         .hasNext();) {
                     Image i = (Image) images.next();
                     i.dispose();
                 }
             }
         });
         editorsTable.setFocus();
         applyDialogFont(dialogArea);
         return dialogArea;
     }

     /**
      * Updates the button state (enabled/disabled)
      */
     private void updateButtons() {
         TableItem selectedItems[] = editorsTable.getSelection();
         boolean hasDirty = false;
         for (int i = 0; i < selectedItems.length; i++) {
             Adapter editor = (Adapter) selectedItems[i].getData();
             if (editor.isDirty()) {
                 hasDirty = true;
                 break;
             }
         }
         saveSelected.setEnabled(hasDirty);

         TableItem allItems[] = editorsTable.getItems();
         boolean hasClean = false;
         for (int i = 0; i < allItems.length; i++) {
             Adapter editor = (Adapter) allItems[i].getData();
             if (!editor.isDirty()) {
                 hasClean = true;
                 break;
             }
         }
         selectClean.setEnabled(hasClean);
         invertSelection.setEnabled(allItems.length > 0);
         closeSelected.setEnabled(selectedItems.length > 0);

         Button ok = getOkButton();
         if (ok != null) {
             ok.setEnabled(selectedItems.length == 1);
         }
     }

     /**
      * Closes the specified editors
      */
     private void closeItems(TableItem items[]) {
         if (items.length == 0) {
             return;
         }
         for (int i = 0; i < items.length; i++) {
             Adapter e = (Adapter) items[i].getData();
             e.close();
         }
         updateItems();
     }

     /**
      * Saves the specified editors
      */
     private void saveItems(TableItem items[], IProgressMonitor monitor) {
         if (items.length == 0) {
             return;
         }
         ProgressMonitorDialog pmd = new ProgressMonitorJobsDialog(getShell());
         pmd.open();
         for (int i = 0; i < items.length; i++) {
             Adapter editor = (Adapter) items[i].getData();
             editor.save(pmd.getProgressMonitor());
             updateItem(items[i], editor);
         }
         pmd.close();
         updateItems();
     }

     /**
      * Returns all clean editors from items[];
      */
     private TableItem[] selectClean(TableItem items[]) {
         if (items.length == 0) {
             return new TableItem[0];
         }
         ArrayList cleanItems = new ArrayList (items.length);
         for (int i = 0; i < items.length; i++) {
             Adapter editor = (Adapter) items[i].getData();
             if (!editor.isDirty()) {
                 cleanItems.add(items[i]);
             }
         }
         TableItem result[] = new TableItem[cleanItems.size()];
         cleanItems.toArray(result);
         return result;
     }

     /**
      * Returns all clean editors from items[];
      */
     private TableItem[] invertedSelection(TableItem allItems[],
             TableItem selectedItems[]) {
         if (allItems.length == 0) {
             return allItems;
         }
         ArrayList invertedSelection = new ArrayList (allItems.length
                 - selectedItems.length);
         outerLoop: for (int i = 0; i < allItems.length; i++) {
             for (int j = 0; j < selectedItems.length; j++) {
                 if (allItems[i] == selectedItems[j]) {
                     continue outerLoop;
                 }
             }
             invertedSelection.add(allItems[i]);
         }
         TableItem result[] = new TableItem[invertedSelection.size()];
         invertedSelection.toArray(result);
         return result;
     }

     /**
      * Updates the specified item
      */
     private void updateItem(TableItem item, Adapter editor) {
         item.setData(editor);
         item.setText(editor.getText());
         Image images[] = editor.getImage();
         for (int i = 0; i < images.length; i++) {
             if (images[i] != null) {
                 item.setImage(i, images[i]);
             }
         }
     }

     /**
      * Adds all editors to elements
      */
     private void updateEditors(IWorkbenchPage[] pages) {
         for (int j = 0; j < pages.length; j++) {
             IEditorReference editors[] = pages[j].getEditorReferences();
             for (int k = 0; k < editors.length; k++) {
                 elements.add(new Adapter(editors[k]));
             }
         }
     }

     /**
      * Updates all items in the table
      */
     private void updateItems() {
         editorsTable.removeAll();
         elements = new ArrayList ();
         if (showAllPersp) {
             IWorkbenchWindow windows[] = window.getWorkbench()
                     .getWorkbenchWindows();
             for (int i = 0; i < windows.length; i++) {
                 updateEditors(windows[i].getPages());
             }
         } else {
             IWorkbenchPage page = window.getActivePage();
             if (page != null) {
                 updateEditors(new IWorkbenchPage[] { page });
             }
         }
         sort();
         Object selection = null;
         if (window.getActivePage() != null) {
             selection = window.getActivePage().getActiveEditor();
         }
         for (Iterator iterator = elements.iterator(); iterator.hasNext();) {
             Adapter e = (Adapter) iterator.next();
             TableItem item = new TableItem(editorsTable, SWT.NULL);
             updateItem(item, e);
             if ((selection != null) && (selection == e.editorRef)) {
                 editorsTable.setSelection(new TableItem[] { item });
             }
         }
         // update the buttons, because the selection may have changed
 updateButtons();
     }

     /**
      * Sorts all the editors according to the table header
      */
     private void sort() {
         //Backward compatible. Table used to have 3 columns.
 if (sortColumn > (editorsTable.getColumnCount() - 1)) {
             sortColumn = 0;
         }
         Adapter a[] = new Adapter[elements.size()];
         elements.toArray(a);
         Arrays.sort(a);
         elements = Arrays.asList(a);
     }

     /**
      * The user has selected a resource and the dialog is closing.
      */
     protected void okPressed() {
         TableItem items[] = editorsTable.getSelection();
         if (items.length != 1) {
             super.okPressed();
             return;
         }

         saveDialogSettings();

         Adapter selection = (Adapter) items[0].getData();
         //It would be better to activate before closing the
 //dialog but it does not work when the editor is in other
 //window. Must investigate.
 super.okPressed();
         selection.activate();
     }

     /**
      * Saves the dialog settings.
      */
     private void saveDialogSettings() {
         IDialogSettings s = getDialogSettings();
         s.put(ALLPERSP, showAllPersp);
         s.put(SORT, sortColumn);
         bounds = getShell().getBounds();
         String array[] = new String [4];
         array[0] = String.valueOf(bounds.x);
         array[1] = String.valueOf(bounds.y);
         array[2] = String.valueOf(bounds.width);
         array[3] = String.valueOf(bounds.height);
         s.put(BOUNDS, array);
         array = new String [editorsTable.getColumnCount()];
         for (int i = 0; i < array.length; i++) {
             array[i] = String.valueOf(editorsTable.getColumn(i).getWidth());
         }
         s.put(COLUMNS, array);
     }

     /**
      * Return a dialog setting section for this dialog
      */
     private IDialogSettings getDialogSettings() {
         IDialogSettings settings = WorkbenchPlugin.getDefault()
                 .getDialogSettings();
         IDialogSettings thisSettings = settings
                 .getSection(getClass().getName());
         if (thisSettings == null) {
             thisSettings = settings.addNewSection(getClass().getName());
         }
         return thisSettings;
     }

     /**
      * A helper inner class to adapt EditorHistoryItem and IEditorPart
      * in the same type.
      */
     private class Adapter implements Comparable {
         IEditorReference editorRef;

         IEditorInput input;

         IEditorDescriptor desc;

         String text[];

         Image images[];

         Adapter(IEditorReference ref) {
             editorRef = ref;
         }

         Adapter(IEditorInput input, IEditorDescriptor desc) {
             this.input = input;
             this.desc = desc;
         }

         boolean isDirty() {
             if (editorRef == null) {
                 return false;
             }
             return editorRef.isDirty();
         }

         boolean isOpened() {
             return editorRef != null;
         }

         void close() {
             if (editorRef == null) {
                 return;
             }
             WorkbenchPage p = ((WorkbenchPartReference) editorRef).getPane()
                     .getPage();
             p.closeEditor(editorRef, true);
         }

         void save(IProgressMonitor monitor) {
             if (editorRef == null) {
                 return;
             }
             IEditorPart editor = (IEditorPart) editorRef.getPart(true);
             if (editor != null) {
                 editor.doSave(monitor);
             }
         }

         String [] getText() {
             if (text != null) {
                 return text;
             }
             text = new String [2];
             if (editorRef != null) {
                 if (editorRef.isDirty()) {
                     text[0] = "*" + editorRef.getTitle(); //$NON-NLS-1$
 } else {
                     text[0] = editorRef.getTitle();
                 }
                 text[1] = editorRef.getTitleToolTip();
             } else {
                 text[0] = input.getName();
                 text[1] = input.getToolTipText();
             }
             return text;
         }

         Image[] getImage() {
             if (images != null) {
                 return images;
             }
             images = new Image[2];
             if (editorRef != null) {
                 images[0] = editorRef.getTitleImage();
                 WorkbenchPage p = ((WorkbenchPartReference) editorRef)
                         .getPane().getPage();
                 IPerspectiveDescriptor persp = p.getPerspective();
                 ImageDescriptor image = persp.getImageDescriptor();
                 if (image == null) {
                     image = WorkbenchImages
                             .getImageDescriptor(IWorkbenchGraphicConstants.IMG_ETOOL_DEF_PERSPECTIVE);
                 }
             } else {
                 ImageDescriptor image = null;
                 if (desc != null) {
                     image = desc.getImageDescriptor();
                 }
                 if (image == null) {
                     IEditorRegistry registry = WorkbenchPlugin.getDefault()
                             .getEditorRegistry();
                     image = registry.getImageDescriptor(input.getName());
                     //TODO: how can this honour content types? Guessing at the content type perhaps?

                     if (image == null) {
                         // @issue what should be the default image?
 // image = registry.getDefaultEditor().getImageDescriptor();
 }
                 }
                 if (image != null) {
                     images[0] = (Image) disabledImageCache.get(image);
                     if (images[0] == null) {
                         Image enabled = image.createImage();
                         Image disabled = new Image(editorsTable.getDisplay(),
                                 enabled, SWT.IMAGE_DISABLE);
                         enabled.dispose();
                         disabledImageCache.put(image, disabled);
                         images[0] = disabled;
                     }
                 }
             }
             return images;
         }

         private void activate() {
             if (editorRef != null) {
                 IEditorPart editor = editorRef.getEditor(true);
                 WorkbenchPage p = (WorkbenchPage) editor.getEditorSite()
                         .getPage();
                 Shell s = p.getWorkbenchWindow().getShell();
                 if (s.getMinimized()) {
                     s.setMinimized(false);
                 }
                 s.moveAbove(null);
                 p.getWorkbenchWindow().setActivePage(p);
                 p.activate(editor);
             } else {
                 IWorkbenchPage p = window.getActivePage();
                 if (p != null) {
                     try {
                         p.openEditor(input, desc.getId(), true);
                     } catch (PartInitException e) {
                     }
                 }
             }
         }

         public int compareTo(Object another) {
             Adapter adapter = (Adapter) another;
             int result = collator.compare(getText()[sortColumn], adapter
                     .getText()[sortColumn]);
             if (result == 0) {
                 int column = sortColumn == 0 ? 1 : 0;
                 result = collator.compare(getText()[column],
                         adapter.getText()[column]);
             }
             if (reverse) {
                 return result * -1;
             }
             return result;
         }
     }
 }

